diff --git a/BlueBerry/BlueBerryConfig.cmake.in b/BlueBerry/BlueBerryConfig.cmake.in
index 6568f028c1..5a5d8bbecf 100644
--- a/BlueBerry/BlueBerryConfig.cmake.in
+++ b/BlueBerry/BlueBerryConfig.cmake.in
@@ -1,87 +1,91 @@
 
 # -------------------------------------------------------------------------
 # Package requirements
 # -------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@BLUEBERRY_SOURCE_DIR@/CMake")
 
 set(CTK_DIR "@CTK_DIR@")
 find_package(CTK REQUIRED)
 
 set(mbilog_DIR "@mbilog_DIR@")
 find_package(mbilog REQUIRED)
 
 find_package(Poco REQUIRED)
 
 set(DOXYGEN_EXECUTABLE "@DOXYGEN_EXECUTABLE@")
 set(DOXYGEN_DOT_EXECUTABLE "@DOXYGEN_DOT_EXECUTABLE@")
 
 find_package(Doxygen)
 
 
 # -------------------------------------------------------------------------
 # BlueBerry directory vars
 # -------------------------------------------------------------------------
 
 set(BLUEBERRY_PLUGINS_SOURCE_DIR "@BLUEBERRY_PLUGINS_SOURCE_DIR@")
 set(BLUEBERRY_PLUGINS_BINARY_DIR "@BLUEBERRY_PLUGINS_BINARY_DIR@")
 
 set(BLUEBERRY_PLUGIN_SOURCE_DIRS "@BLUEBERRY_PLUGINS_SOURCE_DIR@")
 
 set(BLUEBERRY_SOURCE_DIR "@BLUEBERRY_SOURCE_DIR@")
 set(BlueBerry_SOURCE_DIR "@BLUEBERRY_SOURCE_DIR@")
 set(BLUEBERRY_BINARY_DIR "@BLUEBERRY_BINARY_DIR@")
 
 
 # -------------------------------------------------------------------------
 # BlueBerry CMake file includes
 # -------------------------------------------------------------------------
 
 set(BLUEBERRY_PLUGIN_USE_FILE @BB_PLUGIN_USE_FILE@)
 if(BLUEBERRY_PLUGIN_USE_FILE)
   if(EXISTS ${BLUEBERRY_PLUGIN_USE_FILE})
     include(${BLUEBERRY_PLUGIN_USE_FILE})
   endif()
 endif()
 
 if(NOT BB_PLUGIN_EXPORTS_FILE_INCLUDED AND NOT CMAKE_PROJECT_NAME STREQUAL "MITK")
   include("@BB_PLUGIN_EXPORTS_FILE@")
   set(BB_PLUGIN_EXPORTS_FILE_INCLUDED 1)
 endif()
 
 
 # -------------------------------------------------------------------------
 # BlueBerry CMake variables
 # -------------------------------------------------------------------------
 
 set(BLUEBERRY_DEBUG_POSTFIX @BLUEBERRY_DEBUG_POSTFIX@)
 
 set(BLUEBERRY_USE_QT_HELP @BLUEBERRY_USE_QT_HELP@)
+if(BLUEBERRY_USE_QT_HELP AND NOT DOXYGEN_VERSION VERSION_EQUAL "1.8.0")
+  message("Setting BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.0 not found.")
+  set(BLUEBERRY_USE_QT_HELP OFF)
+endif()
 
 set(BLUEBERRY_QTPLUGIN_PATH "@BLUEBERRY_QTPLUGIN_PATH@")
 
 set(QT_HELPGENERATOR_EXECUTABLE "@QT_HELPGENERATOR_EXECUTABLE@")
 set(QT_COLLECTIONGENERATOR_EXECUTABLE "@QT_COLLECTIONGENERATOR_EXECUTABLE@")
 set(QT_ASSISTANT_EXECUTABLE "@QT_ASSISTANT_EXECUTABLE@")
 set(QT_XMLPATTERNS_EXECUTABLE "@QT_XMLPATTERNS_EXECUTABLE@")
 
 set(BLUEBERRY_PLUGIN_TARGETS @my_plugin_targets@)
 
 set(BLUEBERRY_PLUGIN_PROVISIONING_FILE "@BLUEBERRY_PROVISIONING_FILE@")
 
 set(BLUEBERRY_DOXYGEN_TAGFILE_NAME @BLUEBERRY_DOXYGEN_TAGFILE_NAME@)
 
 
 # -------------------------------------------------------------------------
 # BlueBerry CMake macros
 # -------------------------------------------------------------------------
 
 include(MacroParseArguments)
 include(MacroConvertSchema)
 include(MacroOrganizeSources)
 include(MacroCreateCTKPlugin)
 include(MacroCreateQtHelp)
 include(MacroInstallCTKPlugin)
 include(FunctionInstallThirdPartyCTKPlugins)
 include(FunctionCreateProvisioningFile)
 include(FunctionCreateBlueBerryApplication)
diff --git a/BlueBerry/CMakeLists.txt b/BlueBerry/CMakeLists.txt
index f64a32ce98..03f3d05a28 100644
--- a/BlueBerry/CMakeLists.txt
+++ b/BlueBerry/CMakeLists.txt
@@ -1,273 +1,268 @@
 project(BlueBerry)
 cmake_minimum_required(VERSION 2.8.5)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMake/")
 
 include(MacroParseArguments)
 include(MacroConvertSchema)
 include(MacroOrganizeSources)
 include(MacroCreateCTKPlugin)
 include(MacroCreateQtHelp)
 include(MacroInstallCTKPlugin)
 include(FunctionCreateProvisioningFile)
 
 if(MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4275 /wd4251 /wd4503")
 endif()
 
 if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 endif()
 
 find_package(mbilog REQUIRED)
 include_directories(${mbilog_INCLUDE_DIRS})
 
 
 find_package(Qt4 4.7 REQUIRED)
 
 if(QT_QMAKE_CHANGED)
   set(QT_HELPGENERATOR_EXECUTABLE NOTFOUND)
   set(QT_COLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
   set(QT_ASSISTANT_EXECUTABLE NOTFOUND)
   set(QT_XMLPATTERNS_EXECUTABLE NOTFOUND)
 endif()
 
 find_program(QT_HELPGENERATOR_EXECUTABLE
   NAMES qhelpgenerator qhelpgenerator-qt4 qhelpgenerator4
   PATHS ${QT_BINARY_DIR}
   NO_DEFAULT_PATH
 )
 
 find_program(QT_COLLECTIONGENERATOR_EXECUTABLE
   NAMES qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator4
   PATHS ${QT_BINARY_DIR}
   NO_DEFAULT_PATH
 )
 
 find_program(QT_ASSISTANT_EXECUTABLE
   NAMES assistant-qt4 assistant4 assistant
   PATHS ${QT_BINARY_DIR}
   NO_DEFAULT_PATH
 )
 
 find_program(QT_XMLPATTERNS_EXECUTABLE
   NAMES xmlpatterns
   PATHS ${QT_BINARY_DIR}
   NO_DEFAULT_PATH
 )
 
 option(BLUEBERRY_USE_QT_HELP "Enable support for integrating bundle documentation into Qt Help" ON)
 
 mark_as_advanced(BLUEBERRY_USE_QT_HELP
                  QT_HELPGENERATOR_EXECUTABLE
                  QT_COLLECTIONGENERATOR_EXECUTABLE
                  QT_ASSISTANT_EXECUTABLE
                  QT_XMLPATTERNS_EXECUTABLE)
 
-set(_doxygen_too_old 1)
 if(BLUEBERRY_USE_QT_HELP)
   find_package(Doxygen)
-  if(DOXYGEN_FOUND)
-    execute_process(COMMAND ${DOXYGEN_EXECUTABLE} --version
-                    OUTPUT_VARIABLE _doxygen_version)
-    if(${_doxygen_version} VERSION_GREATER 1.6.0 OR
-       ${_doxygen_version} VERSION_EQUAL 1.6.0)
-      set(_doxygen_too_old 0)
-    endif()
-  endif()
-
-  if(_doxygen_too_old)
-    message("Doxygen was not found or is too old. Version 1.6.0 or later is needed if BLUEBERRY_USE_QT_HELP is ON")
-    set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
+  set(_force_blueberry_use_qt_help_to_off 0)
+  if(DOXYGEN_FOUND AND NOT DOXYGEN_VERSION VERSION_EQUAL 1.8.0)
+    message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.0 not found.")
+    set(_force_blueberry_use_qt_help_to_off 1)
   endif()
 
   if(NOT QT_HELPGENERATOR_EXECUTABLE)
-    message("You have enabled Qt Help support, but QT_HELPGENERATOR_EXECUTABLE is empty")
-    set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
+    message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because QT_HELPGENERATOR_EXECUTABLE is empty.")
+    set(_force_blueberry_use_qt_help_to_off 1)
   endif()
 
   if(NOT QT_XMLPATTERNS_EXECUTABLE)
     message("You have enabled Qt Help support, but QT_XMLPATTERNS_EXECUTABLE is empty")
+    set(_force_blueberry_use_qt_help_to_off 1)
+  endif()
+
+  if(_force_blueberry_use_qt_help_to_off)
     set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
   endif()
 endif(BLUEBERRY_USE_QT_HELP)
 
 include(${QT_USE_FILE})
 
 # =========  CTK specific CMake stuff ============
 cmake_policy(SET CMP0012 NEW)
 
 find_package(CTK REQUIRED)
 
 # Extract all library names starting with org_blueberry_
 macro(GetMyTargetLibraries all_target_libraries varname)
   set(re_ctkplugin "^org_blueberry_[a-zA-Z0-9_]+$")
   set(_tmp_list)
   list(APPEND _tmp_list ${all_target_libraries})
   ctkMacroListFilter(_tmp_list re_ctkplugin OUTPUT_VARIABLE ${varname})
 endmacro()
 # ================================================
 
 option(BLUEBERRY_BUILD_ALL_PLUGINS "Build all BlueBerry plugins (overriding selection)" OFF)
 mark_as_advanced(BLUEBERRY_BUILD_ALL_PLUGINS)
 
 if(BLUEBERRY_BUILD_ALL_PLUGINS)
   set(BLUEBERRY_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 option(BLUEBERRY_STATIC "Build all plugins as static libraries" OFF)
 mark_as_advanced(BLUEBERRY_STATIC)
 
 option(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF)
 mark_as_advanced(BLUEBERRY_DEBUG_SMARTPOINTER)
 
 find_package(Poco REQUIRED)
 find_package(Ant)
 find_package(Eclipse)
 
 set(BLUEBERRY_SOURCE_DIR ${BlueBerry_SOURCE_DIR})
 set(BLUEBERRY_BINARY_DIR ${BlueBerry_BINARY_DIR})
 
 set(BLUEBERRY_PLUGINS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Bundles)
 set(BLUEBERRY_PLUGINS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Bundles)
 
 set(OSGI_APP solstice)
 set(OSGI_UI_APP solstice_ui)
 
 if(Eclipse_DIR)
   set(BLUEBERRY_DOC_TOOLS_DIR "${Eclipse_DIR}" CACHE PATH "Directory containing additional tools needed for generating the documentation")
 else()
   set(BLUEBERRY_DOC_TOOLS_DIR "" CACHE PATH "Directory containing additional tools needed for generating the documentation")
 endif()
 
 set(BLUEBERRY_DEBUG_POSTFIX d)
 
 # Testing options
 
 if(DEFINED BLUEBERRY_BUILD_TESTING)
   option(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." ${BLUEBERRY_BUILD_TESTING})
 else()
   option(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." ${BUILD_TESTING})
 endif()
 
 if(WIN32)
   set(_gui_testing_default "ON")
 else()
   set(_gui_testing_default "OFF")
 endif()
 
 option(BLUEBERRY_ENABLE_GUI_TESTING "Enable the BlueBerry GUI tests" ${_gui_testing_default})
 mark_as_advanced(BLUEBERRY_ENABLE_GUI_TESTING)
 
 if(BLUEBERRY_BUILD_TESTING)
   enable_testing()
 endif()
 
 
 # Add CTK plugins
 
 set(_ctk_plugins
   Bundles/org.blueberry.osgi:ON
   Bundles/org.blueberry.compat:OFF
   Bundles/org.blueberry.core.runtime:OFF
   Bundles/org.blueberry.core.expressions:OFF
   Bundles/org.blueberry.solstice.common:OFF
   Bundles/org.blueberry.core.commands:OFF
   Bundles/org.blueberry.core.jobs:OFF
   Bundles/org.blueberry.ui:OFF
   Bundles/org.blueberry.ui.qt:OFF
   Bundles/org.blueberry.ui.qt.help:OFF
   Bundles/org.blueberry.ui.qt.log:ON
   Bundles/org.blueberry.ui.qt.objectinspector:OFF
 )
 
 set(_ctk_test_plugins )
 
 set(_ctk_plugins_include_dirs
   ${Poco_INCLUDE_DIRS}
 )
 
 include_directories(${_ctk_plugins_include_dirs})
 
 if(BLUEBERRY_BUILD_TESTING)
   find_package(CppUnit REQUIRED)
   include(berryTestingHelpers)
 
   set(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}")
   get_target_property(_is_macosx_bundle ${OSGI_APP} MACOSX_BUNDLE)
   if(APPLE AND _is_macosx_bundle)
     set(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.app/Contents/MacOS/${OSGI_APP}")
   endif()
 
   set(_ctk_testinfrastructure_plugins
     Bundles/org.blueberry.test:ON
     Bundles/org.blueberry.uitest:ON
   )
 
   set(_ctk_test_plugins
 #    Testing/org.blueberry.core.runtime.tests:ON
 #    Testing/org.blueberry.osgi.tests:ON
   )
 
   if(BLUEBERRY_ENABLE_GUI_TESTING)
 #    list(APPEND _ctk_test_plugins Testing/org.blueberry.ui.tests:ON)
 
     set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}")
     get_target_property(_is_macosx_bundle ${OSGI_UI_APP} MACOSX_BUNDLE)
     if(APPLE AND _is_macosx_bundle)
       set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}.app/Contents/MacOS/${OSGI_UI_APP}")
     endif()
   endif()
 endif()
 
 set(BLUEBERRY_TESTING_PROVISIONING_FILE "${BlueBerry_BINARY_DIR}/BlueBerryTesting.provisioning")
 
 add_custom_target(BlueBerry)
 
 ctkMacroSetupPlugins(${_ctk_plugins} ${_ctk_testinfrastructure_plugins} ${_ctk_test_plugins}
                      BUILD_OPTION_PREFIX BLUEBERRY_BUILD_
                      BUILD_ALL ${BLUEBERRY_BUILD_ALL_PLUGINS}
                      COMPACT_OPTIONS)
 
 set(BLUEBERRY_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerry.provisioning")
 FunctionCreateProvisioningFile(
   FILE ${BLUEBERRY_PROVISIONING_FILE}
   PLUGINS ${_ctk_plugins}
 )
 
 FunctionCreateProvisioningFile(
   FILE ${BLUEBERRY_TESTING_PROVISIONING_FILE}
   INCLUDE ${BLUEBERRY_PROVISIONING_FILE}
   PLUGINS ${_ctk_testinfrastructure_plugins} ${_ctk_test_plugins}
 )
 
 if(${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES)
   add_dependencies(BlueBerry ${${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES})
 endif()
 set_property(TARGET ${${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES} PROPERTY LABELS BlueBerry)
 
 set(BB_PLUGIN_USE_FILE "${BlueBerry_BINARY_DIR}/BlueBerryPluginUseFile.cmake")
 if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
   ctkFunctionGeneratePluginUseFile(${BB_PLUGIN_USE_FILE})
 else()
   file(REMOVE ${BB_PLUGIN_USE_FILE})
   set(BB_PLUGIN_USE_FILE )
 endif()
 
 # CTK Plugin Exports
 set(BB_PLUGIN_EXPORTS_FILE "${CMAKE_CURRENT_BINARY_DIR}/BlueBerryPluginExports.cmake")
 GetMyTargetLibraries("${${PROJECT_NAME}_PLUGIN_LIBRARIES}" my_plugin_targets)
 set(additional_export_targets mbilog)
 export(TARGETS ${my_plugin_targets} ${additional_export_targets}
        FILE ${BB_PLUGIN_EXPORTS_FILE})
 
 
 add_subdirectory(Documentation)
 
 set(BLUEBERRY_QTPLUGIN_PATH )
 if(CTK_QTDESIGNERPLUGINS_DIR AND EXISTS ${CTK_QTDESIGNERPLUGINS_DIR})
   set(BLUEBERRY_QTPLUGIN_PATH "${CTK_QTDESIGNERPLUGINS_DIR}")
 endif()
 
 configure_file(BlueBerryConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/BlueBerryConfig.cmake @ONLY)
 
diff --git a/Documentation/CMakeLists.txt b/Documentation/CMakeLists.txt
index ba8bb90405..047135a1a2 100644
--- a/Documentation/CMakeLists.txt
+++ b/Documentation/CMakeLists.txt
@@ -1,185 +1,189 @@
 #
 # Variables:
 #  MITK_DOXYGEN_OUTPUT_DIR: doxygen output directory (optional)
 
 # Compile source code snippets
 #add_subdirectory(Snippets)
 
 find_package(Doxygen)
 
 if(DOXYGEN_FOUND)
 
-# Different doxygen versions produce different significantly different behaviour in the MITK documentation
-# especially in regards to the MITK Qt assistant help files. For this reason we support only one version at a time
-set(supported_doxygen_version "1.8.0")
-
-if(CMAKE_VERSION VERSION_LESS "2.8.8")
-  EXECUTE_PROCESS(COMMAND ${DOXYGEN_EXECUTABLE} "--version" OUTPUT_VARIABLE DOXYGEN_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
-endif()
+# Different doxygen versions produce significantly different behaviour in the MITK documentation
+# especially in regards to the MITK Qt assistant help files and markdown files.
+# The HTML documentation is supposed to be build with Doxygen 1.8.1 whereas the
+# Qt assistant QCH files are supposed to be generated with Doxygen 1.8.0.
+# So we check for 1.8.1 here and QCH generation support is checked in
+# BlueBerry/CMakeLists.txt
+set(supported_doxygen_version "1.8.1")
 
 if(NOT DOXYGEN_VERSION VERSION_EQUAL ${supported_doxygen_version})
-  MESSAGE("Unsupported doxygen version ${DOXYGEN_VERSION}. MITK documentation has been tested to work with doxygen ${supported_doxygen_version}")
+  MESSAGE(WARNING "Unsupported doxygen version ${DOXYGEN_VERSION}. The MITK HTML documentation has been tested to work with doxygen ${supported_doxygen_version}.")
 endif()
 
 option(USE_DOT "Use dot program for generating graphical class diagrams with doxygen, if available" ON)
 option(MITK_DOXYGEN_BUILD_ALWAYS "Always build the MITK documentation when building the default target" OFF)
 option(MITK_DOXYGEN_GENERATE_QCH_FILES "Use doxygen to generate Qt compressed help files for MITK docs" OFF)
 mark_as_advanced(USE_DOT MITK_DOXYGEN_BUILD_ALWAYS MITK_DOXYGEN_GENERATE_QCH_FILES)
+if (MITK_DOXYGEN_GENERATE_QCH_FILES AND NOT DOXYGEN_VERSION VERSION_EQUAL "1.8.0")
+  message(WARNING "> Forcing MITK_DOXYGEN_GENERATE_QCH_FILES to OFF because Doxygen version 1.8.0 not found.")
+  set(MITK_DOXYGEN_GENERATE_QCH_FILES OFF CACHE BOOL "Use doxygen to generate Qt compressed help files for MITK docs" FORCE)
+endif()
 
 set(HAVE_DOT "NO")
 if(DOXYGEN_DOT_EXECUTABLE AND USE_DOT)
   set(HAVE_DOT "YES")
 endif()
 
 set(MITK_DOXYGEN_TAGFILE_NAME ${MITK_DOXYGEN_OUTPUT_DIR}/MITK.tag CACHE INTERNAL "MITK Doxygen tag file")
 
 # This is relative to the working directory of the doxygen command
 set(MITK_DOXYGEN_STYLESHEET mitk_doxygen.css)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${MITK_DOXYGEN_STYLESHEET}
                ${CMAKE_CURRENT_BINARY_DIR}/${MITK_DOXYGEN_STYLESHEET} @COPYONLY)
 
 # Create QCH files for MITK and external projects
 set(MITK_DOXYGEN_GENERATE_QHP "NO")
 if(MITK_DOXYGEN_GENERATE_QCH_FILES)
 
   find_program(QT_HELPGENERATOR_EXECUTABLE
     NAMES qhelpgenerator qhelpgenerator-qt4 qhelpgenerator4
     PATHS ${QT_BINARY_DIR}
     DOC "The location of the the Qt help generator executable"
     NO_DEFAULT_PATH
   )
   mark_as_advanced(QT_HELPGENERATOR_EXECUTABLE)
 
   if(NOT QT_HELPGENERATOR_EXECUTABLE)
     message(SEND_ERROR "The Qt help generator could not be found. Disabling qch generation")
   else()
     set(MITK_DOXYGEN_GENERATE_QHP "YES")
   endif()
 
   # The name of the generated MITK qch file, relative to the
   # Doxygen HTML output folder
   set(MITK_DOXYGEN_QCH_FILE "${MITK_BINARY_DIR}/MITK-${MITK_REVISION_ID}.qch")
 
   # Generating ITK and VTK docs it not done yet
   #option(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE "Use doxygen to generate a Qt compressed help file for VTK docs" OFF)
   #option(MITK_DOXYGEN_GENERATE_ITK_QCH_FILE "Use doxygen to generate a Qt compressed help file for ITK docs" OFF)
   #mark_as_advanced(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE MITK_DOXYGEN_GENERATE_ITK_QCH_FILE)
 
 endif()
 
 
 if(MITK_USE_BLUEBERRY)
   file(RELATIVE_PATH _blueberry_doxygen_path ${MITK_DOXYGEN_OUTPUT_DIR}/html ${BLUEBERRY_DOXYGEN_OUTPUT_DIR}/html)
   set(BLUEBERRY_DOXYGEN_TAGFILE "${BLUEBERRY_DOXYGEN_TAGFILE_NAME}=${_blueberry_doxygen_path}")
   set(BLUEBERRY_DOXYGEN_LINK "<a class=\"el\" href=\"${_blueberry_doxygen_path}/index.html\">BlueBerry Documentation</a>")
   set(MITK_XP_LINK "\\ref mitkExtPointsIndex")
   configure_file(schema.css ${MITK_DOXYGEN_OUTPUT_DIR}/html/schema.css)
 
   set(MITK_DOXYGEN_ENABLED_SECTIONS "${MITK_DOXYGEN_ENABLED_SECTIONS} BLUEBERRY")
 endif(MITK_USE_BLUEBERRY)
 
 # Compile a doxygen input filter for processing CMake scripts
 include(mitkFunctionCMakeDoxygenFilterCompile)
 mitkFunctionCMakeDoxygenFilterCompile(NAMESPACE "CMake")
 
 # Configure some doxygen options
 if(NOT MITK_DOXYGEN_INTERNAL_DOCS)
   set(MITK_DOXYGEN_INTERNAL_DOCS "NO")
   set(MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS "YES")
   set(MITK_DOXYGEN_EXCLUDE_PATTERNS "*_p.* *Private.h */internal/*")
 else()
   set(MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS "NO")
   set(MITK_DOXYGEN_EXCLUDE_PATTERNS "")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_TODOLIST)
   set(MITK_DOXYGEN_GENERATE_TODOLIST "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_BUGLIST)
   set(MITK_DOXYGEN_GENERATE_BUGLIST "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS)
   set(MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_UML_LOOK)
   set(MITK_DOXYGEN_UML_LOOK "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_DEPRECATEDLIST)
   set(MITK_DOXYGEN_GENERATE_DEPRECATEDLIST "YES")
 endif()
 
 if(NOT DEFINED MITK_DOXYGEN_DOT_NUM_THREADS)
   set(MITK_DOXYGEN_DOT_NUM_THREADS 0)
 endif()
 
 configure_file(Doxygen/MainPage.dox.in
                ${CMAKE_CURRENT_BINARY_DIR}/Doxygen/MainPage.dox)
 configure_file(doxygen.conf.in
                ${CMAKE_CURRENT_BINARY_DIR}/doxygen.conf)
 
 if(MITK_DOXYGEN_BUILD_ALWAYS)
   set(_doc_in_all "ALL")
 else()
   set(_doc_in_all "")
 endif()
 
 add_custom_target(doc ${_doc_in_all}
                   ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.conf
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   )
 
 if(MITK_USE_BLUEBERRY)
   # convert the extension points schema files into html
   find_package(Ant)
   if(ANT_FOUND AND BLUEBERRY_DOC_TOOLS_DIR)
 
     list(APPEND MITK_XP_GLOB_EXPRESSIONS
          ${MITK_SOURCE_DIR}/Plugins/plugin.xml)
 
     file(GLOB_RECURSE _plugin_xmls ${MITK_XP_GLOB_EXPRESSIONS})
 
     MACRO_CONVERT_SCHEMA(INPUT ${_plugin_xmls}
                          OUTPUT_DIR "${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html"
                          TARGET_NAME mitkXPDoc
                          )
 
     add_dependencies(doc mitkXPDoc BlueBerryXPDoc)
     #if(${PROJECT_NAME} STREQUAL "MITK")
     #  add_dependencies(doc BlueBerryDoc)
     #endif()
   endif(ANT_FOUND AND BLUEBERRY_DOC_TOOLS_DIR)
 endif(MITK_USE_BLUEBERRY)
 
 #if(MITK_DOXYGEN_GENERATE_ITK_QCH_FILE)
 #  # add the command to generate the ITK documantation
 #  add_custom_target(doc-itk
 #                    COMMAND ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.itk.conf)
 #  add_dependencies(doc doc-itk)
 #endif()
 
 #if(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE)
 #  # add the command to generate the VTK documantation
 #  add_custom_target(doc-vtk
 #                    COMMAND ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.vtk.conf)
 #  add_dependencies(doc doc-vtk)
 #endif()
 
 else(DOXYGEN_FOUND)
 
 # copy blank documentation page to prevent QtHelp from being shown
 # copy the .qhc and .qch files to $MITK_BIN/mitk/bin/ExtBundles/resources/
 
 configure_file(pregenerated/MITKBlankPage.qch
                ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MITKBlankPage.qch
                COPYONLY)
 
 configure_file(pregenerated/MitkExtQtHelpCollection.qhc
                ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MitkExtQtHelpCollection.qhc
                COPYONLY)
 
 endif(DOXYGEN_FOUND)